//处理tree数据结构
export function formatTreeData(data, level = 1, showRename = false, status = 1) {
  return data.map(item => {
    const newItem = { ...item, level, showRename, status: (item.type == 3 || item.type == 4) ? item.studyStatus : status } // 添加 level 属性
    if (newItem.children && newItem.children.length > 0) {
      newItem.children = formatTreeData(newItem.children, level + 1, false, 1) // 递归处理子节点
    }
    return newItem
  })
}

//根据status过滤tree数据
export function processTreeByStatus(tree, status) {
  let result = []

  function processNode(node, targetStatus) {
    if (node.mustLearnStatus == targetStatus && node.type == 3) {
      result.push(node)
    }
    if (node.children) {
      node.children.forEach(child => {
        processNode(child, targetStatus)
      })
    }
  }

  tree.forEach(node => {
    processNode(node, status)
  })

  return result
}

//处理 任务分类后的tree数据结构
export function processTree(tree, mastData, chooseData) {
  function findAndProcessNode(node) {
    if (node.type == 3) {
      if (mastData.some(item => item.id === node.id)) {
        node.mustLearnStatus = 1
      } else if (chooseData.some(item => item.id === node.id)) {
        node.mustLearnStatus = 2
      }
    }
    if (node.children) {
      node.children.forEach(child => {
        findAndProcessNode(child)
      })
    }
  }

  tree.forEach(node => {
    findAndProcessNode(node)
  })

  return tree
}

//添加数据至tree数据里
export function addToChildren(arr, parentId, newObj) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].id === parentId) {
      if (!arr[i].children) {
        arr[i].children = []
      }
      arr[i].children.push(newObj)
      return true
    } else if (arr[i].children) {
      if (addToChildren(arr[i].children, parentId, newObj)) {
        return true
      }
    }
  }
  return false
}

//删除tree数据
export function removeItemById(arr, id) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].id === id) {
      arr.splice(i, 1)
      return true
    } else if (arr[i].children) {
      if (removeItemById(arr[i].children, id)) {
        return true
      }
    }
  }
  return false
}

//改变tree数据studyStatus&&status
export function changeItemById(arr, id) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].indexId === id) {
      arr[i].studyStatus = 2
      arr[i].status = 2
      return true
    } else if (arr[i].children) {
      if (changeItemById(arr[i].children, id)) {
        return true
      }
    }
  }
  return false
}

// 根据indexId获取当前节点
export function getItemById(arr, id) {
  for (const arrElement of arr) {
    if (arrElement.indexId == id) {
      return arrElement
    } else if (arrElement.children) {
      const foundItem = getItemById(arrElement.children, id)
      if (foundItem) {
        return foundItem
      }
    }
  }
}

//获取同级节点 item
export function getSiblingItem(arr, id) {
  // 如果数组为空，返回null
  if (arr.length === 0) {
    return null
  }

  // 查找目标节点及其父级
  const result = findNodeAndParent(arr, null, id)

  if (!result) {
    // 如果没找到目标节点，返回第一个节点
    return arr[0] || null
  }

  const { parent } = result
  const siblingArray = parent ? parent.children : arr

  // 查找同级节点
  for (let i = 0; i < siblingArray.length; i++) {
    if (siblingArray[i].indexId !== id) {
      return siblingArray[i]
    }
  }

  // 如果没有同级节点，返回父级或第一个根节点
  if (parent) {
    return parent // 返回父节点
  } else {
    // 如果是根节点且没有同级，返回其他根节点
    for (let i = 0; i < arr.length; i++) {
      if (arr[i].indexId !== id) {
        return arr[i]
      }
    }
    return null // 如果整个数组只有这一个节点
  }
}
// 辅助函数：查找节点及其父级信息
function findNodeAndParent(arr, parent, id) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].indexId === id) {
      return {
        node: arr[i],
        parent: parent,
        index: i
      }
    }

    if (arr[i].children && arr[i].children.length > 0) {
      const result = findNodeAndParent(arr[i].children, arr[i], id)
      if (result) {
        return result
      }
    }
  }
  return null
}
